home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 February: Tool Chest / Apple Developer CD Series Tool Chest February 1996 (Apple Computer)(1996).iso / Tool Chest / Networking / Network Watch (DMZ) v1.3 / dmz.a next >
Encoding:
Text File  |  1994-06-16  |  6.9 KB  |  244 lines  |  [TEXT/MPS ]
  1. ;_________________________________________________________________________
  2. ;
  3. ; dmz.a
  4. ;_________________________________________________________________________
  5. ;
  6. ; DTS Code Sample
  7. ;    
  8. ; ©1990 Apple Computer, Inc.
  9. ;
  10. ; 3/7/90 - 10/26/90 pvh
  11. ;
  12. ;_________________________________________________________________________
  13.  
  14.     PRINT    PUSH,OFF        ; don't print any of this stuff
  15.  
  16.     INCLUDE 'QuickEqu.a'
  17.     INCLUDE 'ToolEqu.a'
  18.     INCLUDE 'SysEqu.a'
  19.     INCLUDE 'Traps.a'
  20.     INCLUDE 'ATalkEqu.a'
  21.     INCLUDE    'SysErr.a'        
  22.     
  23.     PRINT    POP                ; restore the PRINT options    
  24.  
  25. ;--------------------------------------
  26. ; myVBLSpinInstall
  27. ;
  28. ; 10/90 pvh
  29. ;
  30. ; I hated the ToolLib spinning cursor routines enough to make up my own.  Those routines
  31. ; are fine if you base your spinning cursor off a tight loop where you can continuously call the 
  32. ; routines to actually spin the cursor.  In my case that library was not ideal, so instead
  33. ; I just threw ('slapped' might be the better term) together a VBL task that spins the cursor
  34. ; instead (ala MacApp).
  35. ;
  36. ; This routine & the clean up routine that follows are pretty mcuh self explanatory.  4 cursors
  37. ; are preloaded & locked so they'll be sure to be available when the VBL task is called.  The 
  38. ; task is set up and moved into the application's heap.  The task itself checks a locally saved
  39. ; variable for the cursor ID, loads in that cursor and sets that cursor as the current one if
  40. ; the cursor state is not currently busy (by checking CrsrBusy).
  41. ; 
  42. ; When the task finishes, global references to the VBL task are used in the clean up routine
  43. ; (stopAndRemoveSpinningCursor) to remove the task & associated buffers.  The cursors are also
  44. ; released from memory here.
  45. ;
  46. ; 10/16/90 pvh
  47. ;
  48. ; gMac was imported originally to help support color cursors within this task, but that endeavor
  49. ; was turning out to be too much of a hack (even for me), so it's staying around as a remanant of
  50. ; that failed attempt just to mark another one of my failures.  :-)
  51.  
  52. spinGlobals    RECORD    0        ; this is our global data storage
  53. gtheTaskPtr        DS.L    1        ; pointer to hold task itself
  54. gtheVBLPtr        DS.L    1        ; pointer for VBL task record
  55.           ENDR
  56.  
  57.         EXPORT    (sg):DATA
  58.  
  59. sg            DS    spinGlobals        ; globals for spin cursor
  60.  
  61.  
  62. myVBLSpinInstall    PROC     EXPORT
  63.         IMPORT    gMac : DATA
  64.      
  65. StackFrame    RECORD    {A6Link},DECR        ; build a stack frame record
  66. ParamBegin    EQU    *                        ; start listing parameters here
  67. ParamSize    EQU    ParamBegin-*            ; size of all the passed parameters
  68. RetAddr     DS.L    1                    ; place holder for return address
  69. A6Link        DS.L    1                    ; place holder for A6 link
  70. taskSize     DS.L    1                     ; size of our VBL task
  71. curses        DS.L    4                    ; handle for our cursor
  72. cursType    DS.L    1
  73. LocalSize    EQU     *                    ; size of all the local variables
  74.         ENDR
  75.     
  76.                 WITH    StackFrame, SysEnvRec        ; cover our local stack frame
  77.                 LINK    A6,#LocalSize                ; allocate our local stack frame
  78.                     
  79.                 ; pre-load in the resources to make sure they are around 
  80.                 CLR.L    -(sp)                        ; make space on the stack for result
  81.                 MOVE.L    #'CURS', cursType(a6)        ; another remanant from color stuff (don't ask)
  82.                 MOVE.L    cursType(a6), -(sp)
  83.                 MOVE    #1001, -(sp)
  84.                 _GetResource
  85.                 MOVE.L    (sp)+, curses(a6)
  86.                 MOVE.L    curses(a6), a0
  87.                 _HLock
  88.     
  89.                 CLR.L    -(sp)                        ; make space on the stack for result
  90.                 MOVE.L    cursType(a6), -(sp)
  91.                 MOVE    #1002, -(sp)
  92.                 _GetResource
  93.                 MOVE.L    (sp)+, curses+4(a6)
  94.                 MOVE.L    curses+4(a6), a0
  95.                 _HLock
  96.     
  97.                 CLR.L    -(sp)                        ; make space on the stack for result
  98.                 MOVE.L    cursType(a6), -(sp)
  99.                 MOVE    #1003, -(sp)
  100.                 _GetResource
  101.                 MOVE.L    (sp)+, curses+8(a6)
  102.                 MOVE.L    curses+8(a6), a0
  103.                 _HLock
  104.     
  105.                 CLR.L    -(sp)                        ; make space on the stack for result
  106.                 MOVE.L    cursType(a6), -(sp)
  107.                 MOVE    #1004, -(sp)
  108.                 _GetResource
  109.                 MOVE.L    (sp)+, curses+12(a6)
  110.                 MOVE.L    curses+12(a6), a0
  111.                 _HLock
  112.     
  113.                 BRA.S     theTaskEnd
  114.                 
  115.                 ; actual VBL Task
  116. theTaskBegin
  117.                 MOVEM.L    a0-a6/d0-d7, -(sp)        ; save 
  118.                 BRA.S    afterStorage
  119. A5Storage
  120.                 DC.L    0
  121. afterStorage
  122.                 ; reset the vbl count
  123.                 MOVE.W     #5, vblCount(a0)    
  124.                 
  125.                 ; restore A5 for globals we may have
  126.                 LEA        A5Storage, a0
  127.                 MOVE.L    (a0), a5
  128.                 BRA.S    xxx
  129. cursorStorage                
  130.                 DC.W    $03E9                        ; storage for cursor type, start with first cursor ID
  131. xxx                
  132.                 LEA        cursorStorage, a0
  133.                 ADD.W    #1, (a0)
  134.                 MOVE.W    (a0), d0
  135.                 CMP.W    #1005, d0
  136.                 BLT.S    doCursor
  137.                 
  138.                 MOVE.W    #1001, (a0)                    ; start over with cursor type #1001
  139.                 MOVE.W    #1001, d0                    ; it needs to be in d0
  140. doCursor        
  141.                 CLR.L    -(a7)                        ; make some space for return
  142.                 MOVE.W    d0, -(a7)                    ; move in cursor type
  143.                 _GetCursor
  144.                 MOVE.L    (a7)+, a0                    ; move handle into a0
  145.                 BEQ.S    vblExit                        ; test for nil handle
  146.                 tst.b    CrsrBusy                    ; cursor drawing as we speak?  then split.
  147.                 BNE.S    vblExit
  148.                 MOVE.L    (a0), -(a7)                    ; deref and push on stack
  149.                 _SetCursor            
  150. vblExit
  151.                 MOVEM.L     (sp)+, a0-a6/d0-d7            ; restore 
  152.                 rts
  153. theTaskEnd
  154.                 
  155.                 ; VBL initialization code
  156.                 LEA        theTaskEnd, a0                ; address of tail of task
  157.                 LEA        theTaskBegin, a1            ; head of task
  158.                 MOVE.L    a0, d0                        ; get size of task
  159.                 SUB.L    a1, d0
  160.                 MOVE.L    d0, taskSize(a6)
  161.                 
  162.                 LEA        A5Storage, a0                ; put current A5 into our storage area in code
  163.                 MOVE.L    CurrentA5, (a0)
  164.             
  165.                 ; set up VBL record
  166.                 MOVE.L    #vblPhase+2, d0                ; size of VBLTask
  167.                 _NewPtr    
  168.                 MOVE.L    a0, sg.gtheVBLPtr(a5)
  169.                 
  170.                 ; setup block of memory to hold task itself (in our heap, not the System heap)
  171.                 MOVE.L    taskSize(a6), d0
  172.                 _NewPtr
  173.                 MOVE.L    a0, sg.gtheTaskPtr(a5)
  174.             
  175.                 ; move the task code into block in heap
  176.                 LEA        theTaskBegin, a0            ; head of task
  177.                 MOVE.L    sg.gTheTaskPtr(a5), a1
  178.                 MOVE.L    taskSize(a6), d0
  179.                 _BlockMove
  180.             
  181.                 MOVE.L     sg.gtheTaskPtr(a5), a1
  182.                 MOVE.L    sg.gtheVBLPtr(a5), a0
  183.                 MOVE.L    a1, vblAddr(a0)                ; a1 contains address of moved TheTask
  184.                 MOVE.W     #vType, qType(a0)
  185.                 MOVE.W     #10, vblCount(a0)
  186.                 MOVE.W     #4, vblPhase(a0)            ; whatever
  187.                 _VInstall
  188.     
  189. Exit            UNLK    A6                ; destroy the link
  190.                 MOVEA.L    (SP)+,A0        ; pull off the return address
  191.                 ADDA.L    #ParamSize,SP    ; strip all of the caller's parameters
  192.                 JMP    (A0)                ; return to the caller
  193.             
  194.         ENDP
  195.  
  196. ;--------------------------------------
  197. ; this routine disposes of the VBL spinning cursor task & removes memory allocated for the
  198. ; task.  also unloads the cursors from the heap.
  199.  
  200. stopAndRemoveSpinningCursor    PROC     EXPORT
  201.     
  202.         IMPORT    gtheTaskPtr : DATA
  203.         IMPORT    gtheVBLPtr : DATA
  204.              
  205.                 MOVE.L    sg.gtheVBLPtr, a0
  206.                 _VRemove
  207.                 
  208.                 MOVE.L    sg.gtheVBLPtr, a0
  209.                 _DisposPtr
  210.                 
  211.                 MOVE.L    sg.gtheTaskPtr, a0
  212.                 _DisposPtr
  213.                 
  214.                 ; unload the cursors 
  215.                 CLR.L    -(sp)
  216.                 MOVE.L    #'CURS', -(sp)
  217.                 MOVE    #1001, -(sp)
  218.                 _GetResource
  219.                 _ReleaseResource
  220.     
  221.                 CLR.L    -(sp)
  222.                 MOVE.L    #'CURS', -(sp)
  223.                 MOVE    #1002, -(sp)
  224.                 _GetResource
  225.                 _ReleaseResource
  226.     
  227.                 CLR.L    -(sp)
  228.                 MOVE.L    #'CURS', -(sp)
  229.                 MOVE    #1003, -(sp)
  230.                 _GetResource
  231.                 _ReleaseResource
  232.     
  233.                 CLR.L    -(sp)
  234.                 MOVE.L    #'CURS', -(sp)
  235.                 MOVE    #1004, -(sp)
  236.                 _GetResource
  237.                 _ReleaseResource
  238.  
  239.                 rts
  240.                 
  241.         ENDP
  242. ;--------------------------------------
  243.         END                ; end of this source file
  244.